home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 24 / Amiga Format AFCD24 (Feb 1998, Issue 108).iso / -in_the_mag- / emulation / macos / uae069b2.src.cpt.hqx / UAE069ß2.SRC.CPT / uae069fl2.src / newcpu.c < prev    next >
C/C++ Source or Header  |  1997-06-13  |  33KB  |  1,285 lines
  1.  /* 
  2.   * UAE - The Un*x Amiga Emulator
  3.   * 
  4.   * MC68000 emulation
  5.   *
  6.   * (c) 1995 Bernd Schmidt
  7.   */
  8.  
  9. #include "sysconfig.h"
  10. #include "sysdeps.h"
  11.  
  12. #include "config.h"
  13. #include "options.h"
  14. #include "gensound.h"
  15. #include "sounddep/sound.h"
  16. #include "events.h"
  17. #include "uae.h"
  18. #include "machdep/m68k.h"
  19. #include "my_memory.h"
  20. #include "custom.h"
  21. #include "readcpu.h"
  22. #include "newcpu.h"
  23. #include "autoconf.h"
  24. #include "ersatz.h"
  25. #include "debug.h"
  26. #include "compiler.h"
  27.  
  28. int areg_byteinc[] = { 1,1,1,1,1,1,1,2 };
  29. int imm8_table[] = { 8,1,2,3,4,5,6,7 };
  30.  
  31. int movem_index1[256];
  32. int movem_index2[256];
  33. int movem_next[256];
  34.  
  35. int fpp_movem_index1[256];
  36. int fpp_movem_index2[256];
  37. int fpp_movem_next[256];
  38.  
  39. cpuop_func *cpufunctbl[65536];
  40. #if USER_PROGRAMS_BEHAVE > 0
  41. cpuop_func *cpufunctbl_behaved[65536];
  42. #endif
  43.  
  44. #ifndef NO_PREFETCH_BUFFER
  45. /* Oh boy does this suck... */
  46. void fill_prefetch(void)
  47. {
  48.     /* We can't use clever code on all machines. */
  49. #ifdef UNALIGNED_PROFITABLE
  50.     uae_u32 v1, v2, v3, v4;
  51.     v1 = *(uae_u32 *)regs.pc_p;
  52.     v2 = *(uae_u32 *)(regs.pc_p+4);
  53.     v3 = *(uae_u32 *)(regs.pc_p+8);
  54.     v4 = *(uae_u32 *)(regs.pc_p+12);
  55.     *(uae_u32 *)(regs.prefetch) = v1;
  56.     *(uae_u32 *)(regs.prefetch+4) = v2;
  57.     *(uae_u32 *)(regs.prefetch+8) = v3;
  58.     *(uae_u32 *)(regs.prefetch+12) = v4;
  59. #else
  60.     memcpy (regs.prefetch, regs.pc_p, sizeof regs.prefetch);
  61. #endif
  62.     regs.prefetch_pos = regs.prefetch;
  63. }
  64.  
  65. uae_u32 nextibyte(void)
  66. {
  67.     uae_u32 v = do_get_mem_byte (regs.prefetch_pos + 1);
  68.     *(uae_u16 *)regs.prefetch_pos = *(uae_u16 *)(regs.pc_p + 16);
  69.     regs.pc_p += 2;
  70.     regs.prefetch_pos += 2;
  71.     if (regs.prefetch_pos == regs.prefetch + 16)
  72.     regs.prefetch_pos = regs.prefetch;
  73.     return v;
  74. }
  75.  
  76. uae_u32 nextiword(void)
  77. {
  78.     uae_u32 v = do_get_mem_word ((uae_u16 *)regs.prefetch_pos);
  79.     *(uae_u16 *)regs.prefetch_pos = *(uae_u16 *)(regs.pc_p + 16);
  80.     regs.pc_p += 2;
  81.     regs.prefetch_pos += 2;
  82.     if (regs.prefetch_pos == regs.prefetch + 16)
  83.     regs.prefetch_pos = regs.prefetch;
  84.     return v;
  85. }
  86.  
  87. uae_u32 nextilong(void)
  88. {
  89.     uae_u32 v;
  90.     if (regs.prefetch_pos == regs.prefetch + 14) {
  91.     v = do_get_mem_word ((uae_u16 *)regs.prefetch_pos);
  92.     v <<= 16;
  93.     v |= do_get_mem_word ((uae_u16 *)regs.prefetch);
  94.     *(uae_u16 *)regs.prefetch_pos = *(uae_u16 *)(regs.pc_p + 16);
  95.     *(uae_u16 *)regs.prefetch = *(uae_u16 *)(regs.pc_p + 18);
  96.     regs.pc_p += 4;
  97.     regs.prefetch_pos = regs.prefetch + 2;
  98.     } else {
  99.     v = do_get_mem_long ((uae_u32 *)regs.prefetch_pos);
  100. #ifdef UNALIGNED_PROFITABLE
  101.     *(uae_u32 *)regs.prefetch_pos = *(uae_u32 *)(regs.pc_p + 16);
  102. #else
  103.     *(uae_u16 *)regs.prefetch_pos = *(uae_u16 *)(regs.pc_p + 16);
  104.     *(uae_u16 *)(regs.prefetch_pos+2) = *(uae_u16 *)(regs.pc_p + 18);    
  105. #endif
  106.     regs.pc_p += 4;
  107.     regs.prefetch_pos += 4;
  108.     if (regs.prefetch_pos == regs.prefetch + 16)
  109.         regs.prefetch_pos = regs.prefetch;
  110.     }
  111.     return v;
  112. }
  113. #endif
  114.  
  115. uaecptr m68k_currentpc(void)
  116. {
  117.     return m68k_getpc();
  118. }
  119.  
  120. #define COUNT_INSTRS 0
  121.  
  122. #if COUNT_INSTRS
  123. static unsigned long int instrcount[65536];
  124. static uae_u16 opcodenums[65536];
  125.  
  126. static int compfn(const void *el1, const void *el2)
  127. {
  128.     return instrcount[*(const uae_u16 *)el1] < instrcount[*(const uae_u16 *)el2];
  129. }
  130.  
  131. void dump_counts(void)
  132. {
  133.     FILE *f = fopen(getenv("INSNCOUNT") ? getenv("INSNCOUNT") : "insncount", "w");
  134.     unsigned long int total = 0;
  135.     int i;
  136.     
  137.     for(i=0; i < 65536; i++) {
  138.     opcodenums[i] = i;
  139.         total += instrcount[i];
  140.     }
  141.     qsort(opcodenums, 65536, sizeof(uae_u16), compfn);
  142.     
  143.     fprintf(f, "Total: %lu\n", total);
  144.     for(i=0; i < 65536; i++) {
  145.     unsigned long int cnt = instrcount[opcodenums[i]];
  146.     struct instr *dp;
  147.     struct mnemolookup *lookup;
  148.     if (!cnt)
  149.         break;
  150.     dp = table68k + opcodenums[i];
  151.     for (lookup = lookuptab;lookup->mnemo != dp->mnemo; lookup++) ;
  152.     fprintf(f, "%04x: %lu %s\n", opcodenums[i], cnt, lookup->name);
  153.     }
  154.     fclose(f);
  155. }
  156. #else
  157. void dump_counts(void)
  158. {
  159. }
  160. #endif
  161.  
  162. int broken_in;
  163.  
  164. void init_m68k (void)
  165. {
  166.     long int opcode;
  167.     int i,j;
  168.     
  169.     for (i = 0 ; i < 256 ; i++) {
  170.     for (j = 0 ; j < 8 ; j++) {
  171.         if (i & (1 << j)) break;
  172.     }
  173.     movem_index1[i] = j;
  174.     movem_index2[i] = 7-j;
  175.     movem_next[i] = i & (~(1 << j));
  176.     }
  177.     for (i = 0 ; i < 256 ; i++) {
  178.     for (j = 7 ; j >= 0 ; j--) {
  179.         if (i & (1 << j)) break;
  180.     }
  181.     fpp_movem_index1[i] = j;
  182.     fpp_movem_index2[i] = 7-j;
  183.     fpp_movem_next[i] = i & (~(1 << j));
  184.     }
  185. #if COUNT_INSTRS
  186.     {
  187.         FILE *f = fopen("insncount", "r");
  188.     memset(instrcount, 0, sizeof instrcount);
  189.     if (f) {
  190.         uae_u32 opcode, count, total;
  191.         char name[20];
  192.         fscanf(f,"Total: %lu\n",&total);
  193.         while(fscanf(f,"%lx: %lu %s\n",&opcode,&count,name)==3) {
  194.         instrcount[opcode] = count;
  195.         }
  196.         fclose(f);
  197.     }
  198.     }
  199. #endif
  200.     write_log("Building CPU table...\n");
  201.     read_table68k ();
  202.     do_merges ();
  203.     for (opcode = 0; opcode < 65536; opcode++)
  204.     cpufunctbl[opcode] = op_illg;
  205.     for (i = 0; op_smalltbl[i].handler != NULL; i++) {
  206.     if (!op_smalltbl[i].specific)
  207.         cpufunctbl[op_smalltbl[i].opcode] = op_smalltbl[i].handler;
  208.     }
  209.     for (opcode = 0; opcode < 65536; opcode++) {
  210.     cpuop_func *f;
  211.     
  212.     if (table68k[opcode].mnemo == i_ILLG)
  213.         continue;
  214.     
  215.     if (table68k[opcode].handler != -1) {
  216.         f = cpufunctbl[table68k[opcode].handler];
  217.         if (f == op_illg)
  218.         abort();
  219.         cpufunctbl[opcode] = f;
  220.     }
  221.     }    
  222.     for (i = 0; op_smalltbl[i].handler != NULL; i++) {
  223.     if (op_smalltbl[i].specific)
  224.         cpufunctbl[op_smalltbl[i].opcode] = op_smalltbl[i].handler;
  225.     }
  226. #if USER_PROGRAMS_BEHAVE > 0
  227.     for (opcode = 0; opcode < 65536; opcode++)
  228.     cpufunctbl_behaved[opcode] = op_illg;
  229.  
  230.     for (i = 0; op_direct_smalltbl[i].handler != NULL; i++) {
  231.     if (!op_direct_smalltbl[i].specific)
  232.         cpufunctbl_behaved[op_direct_smalltbl[i].opcode] = op_direct_smalltbl[i].handler;
  233.     }
  234.     for (opcode = 0; opcode < 65536; opcode++) {
  235.     cpuop_func *f;
  236.     
  237.     if (table68k[opcode].mnemo == i_ILLG)
  238.         continue;
  239.     
  240.     if (table68k[opcode].handler != -1) {
  241.         f = cpufunctbl_behaved[table68k[opcode].handler];
  242.         if (f == op_illg)
  243.         abort();
  244.         cpufunctbl_behaved[opcode] = f;
  245.     }
  246.     }    
  247.     for (i = 0; op_direct_smalltbl[i].handler != NULL; i++) {
  248.     if (op_direct_smalltbl[i].specific)
  249.         cpufunctbl_behaved[op_direct_smalltbl[i].opcode] = op_direct_smalltbl[i].handler;
  250.     }
  251. #endif
  252. }
  253.  
  254. struct regstruct regs, lastint_regs;
  255. static struct regstruct regs_backup[16];
  256. static int backup_pointer = 0;
  257. int lastint_no;
  258.  
  259. uae_s32 ShowEA(int reg, amodes mode, wordsizes size, char *buf)
  260. {
  261.     uae_u16 dp;
  262.     uae_s8 disp8;
  263.     uae_s16 disp16;
  264.     int r;
  265.     uae_u32 dispreg;
  266.     uaecptr addr;
  267.     uae_s32 offset = 0;
  268.     char buffer[80];
  269.     
  270.     switch(mode){
  271.      case Dreg:
  272.     sprintf(buffer,"D%d", reg);
  273.     break;
  274.      case Areg:
  275.     sprintf(buffer,"A%d", reg);
  276.     break;
  277.      case Aind:
  278.     sprintf(buffer,"(A%d)", reg);
  279.     break;
  280.      case Aipi:
  281.     sprintf(buffer,"(A%d)+", reg);
  282.     break;
  283.      case Apdi:
  284.     sprintf(buffer,"-(A%d)", reg);
  285.     break;
  286.      case Ad16:
  287.     disp16 = nextiword();
  288.     addr = m68k_areg(regs,reg) + (uae_s16)disp16;
  289.     sprintf(buffer,"(A%d,$%04x) == $%08lx", reg, disp16 & 0xffff,
  290.                     (long unsigned int)addr);
  291.     break;
  292.      case Ad8r:
  293.     dp = nextiword();
  294.     disp8 = dp & 0xFF;
  295.     r = (dp & 0x7000) >> 12;
  296.     dispreg = dp & 0x8000 ? m68k_areg(regs,r) : m68k_dreg(regs,r);    
  297.     if (!(dp & 0x800)) dispreg = (uae_s32)(uae_s16)(dispreg);
  298.     dispreg <<= (dp >> 9) & 3;
  299.     
  300.     if (dp & 0x100) {
  301.         uae_s32 outer = 0, disp = 0;
  302.         uae_s32 base = m68k_areg(regs,reg);
  303.         char name[10];
  304.         sprintf(name,"A%d, ",reg);
  305.         if (dp & 0x80) { base = 0; name[0] = 0; }
  306.         if (dp & 0x40) dispreg = 0;
  307.         if ((dp & 0x30) == 0x20) disp = (uae_s32)(uae_s16)nextiword();
  308.         if ((dp & 0x30) == 0x30) disp = nextilong();
  309.         base += disp;
  310.         
  311.         if ((dp & 0x3) == 0x2) outer = (uae_s32)(uae_s16)nextiword();
  312.         if ((dp & 0x3) == 0x3) outer = nextilong();
  313.         
  314.         if (!(dp & 4)) base += dispreg;
  315.         if (dp & 3) base = get_long (base);
  316.         if (dp & 4) base += dispreg;
  317.         
  318.         addr = base + outer;
  319.         sprintf(buffer,"(%s%c%d.%c*%d+%ld)+%ld == $%08lx", name, 
  320.                dp & 0x8000 ? 'A' : 'D', (int)r, dp & 0x800 ? 'L' : 'W',
  321.                1 << ((dp >> 9) & 3),
  322.                disp,outer,
  323.                (long unsigned int)addr);
  324.     }
  325.     else {
  326.       addr = m68k_areg(regs,reg) + (uae_s32)((uae_s8)disp8) + dispreg;
  327.       sprintf(buffer,"(A%d, %c%d.%c*%d, $%02x) == $%08lx", reg, 
  328.            dp & 0x8000 ? 'A' : 'D', (int)r, dp & 0x800 ? 'L' : 'W',
  329.            1 << ((dp >> 9) & 3), disp8,
  330.            (long unsigned int)addr);
  331.     }
  332.     break;
  333.      case PC16:
  334.     addr = m68k_getpc();
  335.     disp16 = nextiword();
  336.     addr += (uae_s16)disp16;
  337.     sprintf(buffer,"(PC,$%04x) == $%08lx", disp16 & 0xffff,(long unsigned int)addr);
  338.     break;
  339.      case PC8r:
  340.     addr = m68k_getpc();
  341.     dp = nextiword();
  342.     disp8 = dp & 0xFF;
  343.     r = (dp & 0x7000) >> 12;
  344.     dispreg = dp & 0x8000 ? m68k_areg(regs,r) : m68k_dreg(regs,r);
  345.     if (!(dp & 0x800)) dispreg = (uae_s32)(uae_s16)(dispreg);
  346.     dispreg <<= (dp >> 9) & 3;
  347.     
  348.     if (dp & 0x100) {
  349.         uae_s32 outer = 0,disp = 0;
  350.         uae_s32 base = addr;
  351.         char name[10];
  352.         sprintf(name,"PC, ");
  353.         if (dp & 0x80) { base = 0; name[0] = 0; }
  354.         if (dp & 0x80) base = 0;
  355.         if (dp & 0x40) dispreg = 0;
  356.         if ((dp & 0x30) == 0x20) disp = (uae_s32)(uae_s16)nextiword();
  357.         if ((dp & 0x30) == 0x30) disp = nextilong();
  358.         base += disp;
  359.         
  360.         if ((dp & 0x3) == 0x2) outer = (uae_s32)(uae_s16)nextiword();
  361.         if ((dp & 0x3) == 0x3) outer = nextilong();
  362.         
  363.         if (!(dp & 4)) base += dispreg;
  364.         if (dp & 3) base = get_long (base);
  365.         if (dp & 4) base += dispreg;
  366.         
  367.         addr = base + outer;
  368.         sprintf(buffer,"(%s%c%d.%c*%d+%ld)+%ld == $%08lx", name,
  369.                dp & 0x8000 ? 'A' : 'D', (int)r, dp & 0x800 ? 'L' : 'W',
  370.                1 << ((dp >> 9) & 3),
  371.                disp,outer,
  372.                (long unsigned int)addr);
  373.     } else {
  374.       addr += (uae_s32)((uae_s8)disp8) + dispreg;
  375.       sprintf(buffer,"(PC, %c%d.%c*%d, $%02x) == $%08lx", dp & 0x8000 ? 'A' : 'D', 
  376.         (int)r, dp & 0x800 ? 'L' : 'W',  1 << ((dp >> 9) & 3),
  377.         disp8, (long unsigned int)addr);
  378.     }
  379.     break;
  380.      case absw:
  381.     sprintf(buffer,"$%08lx", (long unsigned int)(uae_s32)(uae_s16)nextiword());
  382.     break;
  383.      case absl:
  384.     sprintf(buffer,"$%08lx", (long unsigned int)nextilong());
  385.     break;
  386.      case imm:
  387.     switch(size){
  388.      case sz_byte:
  389.         sprintf(buffer,"#$%02x", (unsigned int)(nextiword() & 0xff)); break;
  390.      case sz_word:
  391.         sprintf(buffer,"#$%04x", (unsigned int)(nextiword() & 0xffff)); break;
  392.      case sz_long:
  393.         sprintf(buffer,"#$%08lx", (long unsigned int)(nextilong())); break;
  394.      default:
  395.         break;
  396.     }
  397.     break;
  398.      case imm0:
  399.     offset = (uae_s32)(uae_s8)nextiword();
  400.     sprintf(buffer,"#$%02x", (unsigned int)(offset & 0xff));
  401.     break;
  402.      case imm1:
  403.     offset = (uae_s32)(uae_s16)nextiword();
  404.     sprintf(buffer,"#$%04x", (unsigned int)(offset & 0xffff));
  405.     break;
  406.      case imm2:
  407.     offset = (uae_s32)nextilong();
  408.     sprintf(buffer,"#$%08lx", (long unsigned int)offset);
  409.     break;
  410.      case immi:
  411.     offset = (uae_s32)(uae_s8)(reg & 0xff);
  412.     sprintf(buffer,"#$%08lx", (long unsigned int)offset);
  413.     break;
  414.      default:
  415.     break;
  416.     }
  417.     if (buf == 0)
  418.     printf("%s", buffer);
  419.     else
  420.     strcat(buf, buffer);
  421.     return offset;
  422. }
  423.  
  424. void MakeSR(void)
  425. {
  426. #if 0
  427.     assert((regs.t1 & 1) == regs.t1);
  428.     assert((regs.t0 & 1) == regs.t0);
  429.     assert((regs.s & 1) == regs.s);
  430.     assert((regs.m & 1) == regs.m);
  431.     assert((XFLG & 1) == XFLG);
  432.     assert((NFLG & 1) == NFLG);
  433.     assert((ZFLG & 1) == ZFLG);
  434.     assert((VFLG & 1) == VFLG);
  435.     assert((CFLG & 1) == CFLG);
  436. #endif
  437.     regs.sr = ((regs.t1 << 15) | (regs.t0 << 14)
  438.            | (regs.s << 13) | (regs.m << 12) | (regs.intmask << 8)
  439.            | (XFLG << 4) | (NFLG << 3) | (ZFLG << 2) | (VFLG << 1) 
  440.            |  CFLG);
  441. }
  442.  
  443. void MakeFromSR(void)
  444. {
  445.     int oldm = regs.m;
  446.     int olds = regs.s;
  447.  
  448.     regs.t1 = (regs.sr >> 15) & 1;
  449.     regs.t0 = (regs.sr >> 14) & 1;
  450.     regs.s = (regs.sr >> 13) & 1;
  451.     regs.m = (regs.sr >> 12) & 1;
  452.     regs.intmask = (regs.sr >> 8) & 7;
  453.     XFLG = (regs.sr >> 4) & 1;
  454.     NFLG = (regs.sr >> 3) & 1;
  455.     ZFLG = (regs.sr >> 2) & 1;
  456.     VFLG = (regs.sr >> 1) & 1;
  457.     CFLG = regs.sr & 1;
  458.     if (CPU_LEVEL >= 2) {
  459.     if (olds != regs.s) {
  460.          if (olds) {
  461.              if (oldm)
  462.              regs.msp = m68k_areg(regs, 7);
  463.              else
  464.              regs.isp = m68k_areg(regs, 7);
  465.              m68k_areg(regs, 7) = regs.usp;
  466.          } else {
  467.              regs.usp = m68k_areg(regs, 7);
  468.              m68k_areg(regs, 7) = regs.m ? regs.msp : regs.isp;
  469.          }
  470.     } else if (olds && oldm != regs.m) {
  471.         if (oldm) {
  472.         regs.msp = m68k_areg(regs, 7);
  473.         m68k_areg(regs, 7) = regs.isp;
  474.         } else {
  475.         regs.isp = m68k_areg(regs, 7);
  476.         m68k_areg(regs, 7) = regs.msp;
  477.         }
  478.     }
  479.     } else {
  480.     if (olds != regs.s) {
  481.          if (olds) {
  482.          regs.isp = m68k_areg(regs, 7);
  483.              m68k_areg(regs, 7) = regs.usp;
  484.          } else {
  485.              regs.usp = m68k_areg(regs, 7);
  486.              m68k_areg(regs, 7) = regs.isp;
  487.          }
  488.      }
  489.     }
  490.     
  491.     regs.spcflags |= SPCFLAG_INT;
  492.     if (regs.t1 || regs.t0)
  493.         regs.spcflags |= SPCFLAG_TRACE;
  494.     else
  495.         regs.spcflags &= ~(SPCFLAG_TRACE | SPCFLAG_DOTRACE);
  496. }
  497. /* Opcode of faulting instruction */
  498. uae_u16 last_op_for_exception_3;
  499. /* PC at fault time */
  500. uaecptr last_addr_for_exception_3;
  501. /* Address that generated the exception */
  502. uaecptr last_fault_for_exception_3;
  503.  
  504. void Exception(int nr, uaecptr oldpc)
  505. {
  506.     compiler_flush_jsr_stack();
  507.     MakeSR();
  508.     if (!regs.s) {
  509.     regs.usp = m68k_areg(regs, 7);
  510.     if (CPU_LEVEL >= 2)
  511.          m68k_areg(regs, 7) = regs.m ? regs.msp : regs.isp;
  512.      else
  513.          m68k_areg(regs, 7) = regs.isp;
  514.     regs.s = 1;
  515.     }
  516.     if (CPU_LEVEL > 0) {
  517.     if (nr == 2 || nr == 3) {
  518.         int i;
  519.         /* @@@ this is probably wrong (?) */
  520.         for (i = 0 ; i < 12 ; i++) {
  521.         m68k_areg(regs, 7) -= 2;
  522.         put_word (m68k_areg(regs, 7), 0);
  523.         }
  524.         m68k_areg(regs, 7) -= 2;
  525.         put_word (m68k_areg(regs, 7), 0xa000 + nr * 4);
  526.     } else if (nr ==5 || nr == 6 || nr == 7 || nr == 9) {
  527.          m68k_areg(regs, 7) -= 4;
  528.          put_long (m68k_areg(regs, 7), oldpc);
  529.          m68k_areg(regs, 7) -= 2;
  530.          put_word (m68k_areg(regs, 7), 0x2000 + nr * 4);
  531.      } else if (regs.m && nr >= 24 && nr < 32) {
  532.          m68k_areg(regs, 7) -= 2;
  533.          put_word (m68k_areg(regs, 7), nr * 4);
  534.          m68k_areg(regs, 7) -= 4;
  535.          put_long (m68k_areg(regs, 7), m68k_getpc ());
  536.          m68k_areg(regs, 7) -= 2;
  537.          put_word (m68k_areg(regs, 7), regs.sr);
  538.          regs.sr |= (1 << 13);
  539.          regs.msp = m68k_areg(regs, 7);
  540.          m68k_areg(regs, 7) = regs.isp;
  541.          m68k_areg(regs, 7) -= 2;
  542.          put_word (m68k_areg(regs, 7), 0x1000 + nr * 4);
  543.      } else {
  544.          m68k_areg(regs, 7) -= 2;
  545.          put_word (m68k_areg(regs, 7), nr * 4);
  546.      }
  547.     } else {
  548.     if (nr == 2 || nr == 3) {
  549.         m68k_areg(regs, 7) -= 12;
  550.         /* ??????? */
  551.         if (nr == 3) {
  552.         put_long (m68k_areg(regs, 7), last_fault_for_exception_3);
  553.         put_word (m68k_areg(regs, 7)+4, last_op_for_exception_3);
  554.         put_long (m68k_areg(regs, 7)+8, last_addr_for_exception_3);
  555.         }
  556.         write_log ("Exception!\n");
  557.         goto kludge_me_do;
  558.     }
  559.     }
  560.     m68k_areg(regs, 7) -= 4;
  561.     put_long (m68k_areg(regs, 7), m68k_getpc ());
  562. kludge_me_do:
  563.     m68k_areg(regs, 7) -= 2;
  564.     put_word (m68k_areg(regs, 7), regs.sr);
  565.     m68k_setpc(get_long(regs.vbr + 4*nr));
  566.     regs.t1 = regs.t0 = regs.m = 0;
  567.     regs.spcflags &= ~(SPCFLAG_TRACE | SPCFLAG_DOTRACE);
  568. }
  569.  
  570. static void Interrupt(int nr)
  571. {
  572.     assert(nr < 8 && nr >= 0);
  573.     lastint_regs = regs;
  574.     lastint_no = nr;
  575.     Exception(nr+24, 0);
  576.     
  577.     regs.intmask = nr;
  578.     regs.spcflags |= SPCFLAG_INT;
  579. }
  580.  
  581. static int caar, cacr;
  582.  
  583. void m68k_move2c (int regno, uae_u32 *regp)
  584. {
  585.     if (CPU_LEVEL == 1 && (regno & 0x7FF) > 1)
  586.     op_illg (0x4E7B);
  587.     else
  588.     switch (regno) {
  589.      case 0: regs.sfc = *regp & 7; break;
  590.      case 1: regs.dfc = *regp & 7; break;
  591.      case 2: cacr = *regp & 0x3; break;    /* ignore C and CE */
  592.      case 0x800: regs.usp = *regp; break;
  593.      case 0x801: regs.vbr = *regp; break;
  594.      case 0x802: caar = *regp &0xfc; break;
  595.      case 0x803: regs.msp = *regp; if (regs.m == 1) m68k_areg(regs, 7) = regs.msp; break;
  596.      case 0x804: regs.isp = *regp; if (regs.m == 0) m68k_areg(regs, 7) = regs.isp; break;
  597.      default:
  598.         op_illg (0x4E7B);
  599.         break;
  600.     }
  601. }
  602.  
  603. void m68k_movec2 (int regno, uae_u32 *regp)
  604. {
  605.     if (CPU_LEVEL == 1 && (regno & 0x7FF) > 1)
  606.     op_illg (0x4E7A);
  607.     else
  608.     switch (regno) {
  609.      case 0: *regp = regs.sfc; break;
  610.      case 1: *regp = regs.dfc; break;
  611.      case 2: *regp = cacr; break;
  612.      case 0x800: *regp = regs.usp; break;
  613.      case 0x801: *regp = regs.vbr; break;
  614.      case 0x802: *regp = caar; break;
  615.      case 0x803: *regp = regs.m == 1 ? m68k_areg(regs, 7) : regs.msp; break;
  616.      case 0x804: *regp = regs.m == 0 ? m68k_areg(regs, 7) : regs.isp; break;
  617.      default:
  618.         op_illg (0x4E7A);
  619.         break;
  620.     }
  621. }
  622.  
  623. static __inline__ int
  624. div_unsigned(uae_u32 src_hi, uae_u32 src_lo, uae_u32 div, uae_u32 *quot, uae_u32 *rem)
  625. {
  626.     uae_u32 q = 0, cbit = 0;
  627.     int i;
  628.  
  629.     if (div <= src_hi) {
  630.         return(1);
  631.     }
  632.     for (i = 0 ; i < 32 ; i++) {
  633.         cbit = src_hi & 0x80000000ul;
  634.         src_hi <<= 1;
  635.         if (src_lo & 0x80000000ul) src_hi++;
  636.         src_lo <<= 1;
  637.         q = q << 1;
  638.         if (cbit || div <= src_hi) {
  639.             q |= 1;
  640.             src_hi -= div;
  641.         }
  642.     }
  643.     *quot = q;
  644.     *rem = src_hi;
  645.     return(0);
  646. }
  647.  
  648. void m68k_divl (uae_u32 opcode, uae_u32 src, uae_u16 extra, uaecptr oldpc)
  649. {
  650. #if defined(uae_s64)
  651.     if (src == 0) {
  652.     Exception(5,oldpc-2);
  653.     return;
  654.     }
  655.     if (extra & 0x800) {
  656.     /* signed variant */
  657.     uae_s64 a = (uae_s64)(uae_s32)m68k_dreg(regs, (extra >> 12) & 7);
  658.     uae_s64 quot, rem;
  659.     
  660.     if (extra & 0x400) {
  661.         a &= 0xffffffffu;
  662.         a |= (uae_s64)m68k_dreg(regs, extra & 7) << 32;
  663.     }
  664.     rem = a % (uae_s64)(uae_s32)src;
  665.     quot = a / (uae_s64)(uae_s32)src;
  666.     if ((quot & UVAL64(0xffffffff80000000)) != 0
  667.         && (quot & UVAL64(0xffffffff80000000)) != UVAL64(0xffffffff80000000))
  668.     {
  669.         VFLG = NFLG = 1;
  670.         CFLG = 0;
  671.     }
  672.     else {
  673.         if (((uae_s32)rem < 0) != ((uae_s64)a < 0)) rem = -rem;
  674.         VFLG = CFLG = 0;
  675.         ZFLG = ((uae_s32)quot) == 0;
  676.         NFLG = ((uae_s32)quot) < 0;
  677.         m68k_dreg(regs, extra & 7) = rem;
  678.         m68k_dreg(regs, (extra >> 12) & 7) = quot;
  679.     }
  680.     } else {
  681.     /* unsigned */
  682.     uae_u64 a = (uae_u64)(uae_u32)m68k_dreg(regs, (extra >> 12) & 7);
  683.     uae_u64 quot, rem;
  684.     
  685.     if (extra & 0x400) {
  686.         a &= 0xffffffffu;
  687.         a |= (uae_u64)m68k_dreg(regs, extra & 7) << 32;
  688.     }
  689.     rem = a % (uae_u64)src;
  690.     quot = a / (uae_u64)src;
  691.     if (quot > 0xffffffffu) {
  692.         VFLG = NFLG = 1;
  693.         CFLG = 0;
  694.     }
  695.     else {
  696.         VFLG = CFLG = 0;
  697.         ZFLG = ((uae_s32)quot) == 0;
  698.         NFLG = ((uae_s32)quot) < 0;
  699.         m68k_dreg(regs, extra & 7) = rem;
  700.         m68k_dreg(regs, (extra >> 12) & 7) = quot;
  701.     }
  702.     }
  703. #else
  704.     if (src == 0) {
  705.     Exception(5,oldpc-2);
  706.     return;
  707.     }
  708.     if (extra & 0x800) {
  709.     /* signed variant */
  710.     uae_s32 lo = (uae_s32)m68k_dreg(regs, (extra >> 12) & 7);
  711.     uae_s32 hi = lo < 0 ? -1 : 0;
  712.     uae_s32 save_high;
  713.     uae_u32 quot, rem;
  714.     uae_u32 sign;
  715.     
  716.     if (extra & 0x400) {
  717.         hi = (uae_s32)m68k_dreg(regs, extra & 7);
  718.     }
  719.     save_high = hi;
  720.     sign = (hi ^ src);
  721.     if (hi < 0) {
  722.         hi = ~hi;
  723.         lo = -lo;
  724.         if (lo == 0) hi++;
  725.     }
  726.     if ((uae_s32)src < 0) src = -src;
  727.     if (div_unsigned(hi, lo, src, ", &rem) ||
  728.         (sign & 0x80000000) ? quot > 0x80000000 : quot > 0x7fffffff) {
  729.         VFLG = NFLG = 1;
  730.         CFLG = 0;
  731.     }
  732.     else {
  733.         if (sign & 0x80000000) quot = -quot;
  734.         if (((uae_s32)rem < 0) != (save_high < 0)) rem = -rem;
  735.         VFLG = CFLG = 0;
  736.         ZFLG = ((uae_s32)quot) == 0;
  737.         NFLG = ((uae_s32)quot) < 0;
  738.         m68k_dreg(regs, extra & 7) = rem;
  739.         m68k_dreg(regs, (extra >> 12) & 7) = quot;
  740.     }
  741.     } else {
  742.     /* unsigned */
  743.     uae_u32 lo = (uae_u32)m68k_dreg(regs, (extra >> 12) & 7);
  744.     uae_u32 hi = 0;
  745.     uae_u32 quot, rem;
  746.     
  747.     if (extra & 0x400) {
  748.         hi = (uae_u32)m68k_dreg(regs, extra & 7);
  749.     }
  750.     if (div_unsigned(hi, lo, src, ", &rem)) {
  751.         VFLG = NFLG = 1;
  752.         CFLG = 0;
  753.     }
  754.     else {
  755.         VFLG = CFLG = 0;
  756.         ZFLG = ((uae_s32)quot) == 0;
  757.         NFLG = ((uae_s32)quot) < 0;
  758.         m68k_dreg(regs, extra & 7) = rem;
  759.         m68k_dreg(regs, (extra >> 12) & 7) = quot;
  760.     }
  761.     }
  762. #endif
  763. }
  764.  
  765. static __inline__ void
  766. mul_unsigned(uae_u32 src1, uae_u32 src2, uae_u32 *dst_hi, uae_u32 *dst_lo)
  767. {
  768.         uae_u32 r0 = (src1 & 0xffff) * (src2 & 0xffff);
  769.         uae_u32 r1 = ((src1 >> 16) & 0xffff) * (src2 & 0xffff);
  770.         uae_u32 r2 = (src1 & 0xffff) * ((src2 >> 16) & 0xffff);
  771.         uae_u32 r3 = ((src1 >> 16) & 0xffff) * ((src2 >> 16) & 0xffff);
  772.     uae_u32 lo;
  773.  
  774.         lo = r0 + ((r1 << 16) & 0xffff0000ul);
  775.         if (lo < r0) r3++;
  776.         r0 = lo;
  777.         lo = r0 + ((r2 << 16) & 0xffff0000ul);
  778.         if (lo < r0) r3++;
  779.         r3 += ((r1 >> 16) & 0xffff) + ((r2 >> 16) & 0xffff);
  780.     *dst_lo = lo;
  781.     *dst_hi = r3;
  782. }
  783.  
  784. void m68k_mull (uae_u32 opcode, uae_u32 src, uae_u16 extra)
  785. {
  786. #if defined(uae_s64)
  787.     if (extra & 0x800) {
  788.     /* signed variant */
  789.     uae_s64 a = (uae_s64)(uae_s32)m68k_dreg(regs, (extra >> 12) & 7);
  790.  
  791.     a *= (uae_s64)(uae_s32)src;
  792.     VFLG = CFLG = 0;
  793.     ZFLG = a == 0;
  794.     NFLG = a < 0;
  795.     if (extra & 0x400)
  796.         m68k_dreg(regs, extra & 7) = a >> 32;
  797.     else if ((a & UVAL64(0xffffffff80000000)) != 0
  798.          && (a & UVAL64(0xffffffff80000000)) != UVAL64(0xffffffff80000000))
  799.     {
  800.         VFLG = 1;
  801.     }
  802.     m68k_dreg(regs, (extra >> 12) & 7) = (uae_u32)a;
  803.     } else {
  804.     /* unsigned */
  805.     uae_u64 a = (uae_u64)(uae_u32)m68k_dreg(regs, (extra >> 12) & 7);
  806.     
  807.     a *= (uae_u64)src;
  808.     VFLG = CFLG = 0;
  809.     ZFLG = a == 0;
  810.     NFLG = ((uae_s64)a) < 0;
  811.     if (extra & 0x400)
  812.         m68k_dreg(regs, extra & 7) = a >> 32;
  813.     else if ((a & UVAL64(0xffffffff00000000)) != 0) {
  814.         VFLG = 1;
  815.     }
  816.     m68k_dreg(regs, (extra >> 12) & 7) = (uae_u32)a;
  817.     }
  818. #else
  819.     if (extra & 0x800) {
  820.     /* signed variant */
  821.     uae_s32 src1,src2;
  822.     uae_u32 dst_lo,dst_hi;
  823.     uae_u32 sign;
  824.  
  825.     src1 = (uae_s32)src;
  826.     src2 = (uae_s32)m68k_dreg(regs, (extra >> 12) & 7);
  827.     sign = (src1 ^ src2);
  828.     if (src1 < 0) src1 = -src1;
  829.     if (src2 < 0) src2 = -src2;
  830.     mul_unsigned((uae_u32)src1,(uae_u32)src2,&dst_hi,&dst_lo);
  831.     if (sign & 0x80000000) {
  832.         dst_hi = ~dst_hi;
  833.         dst_lo = -dst_lo;
  834.         if (dst_lo == 0) dst_hi++;
  835.     }
  836.     VFLG = CFLG = 0;
  837.     ZFLG = dst_hi == 0 && dst_lo == 0;
  838.     NFLG = ((uae_s32)dst_hi) < 0;
  839.     if (extra & 0x400)
  840.         m68k_dreg(regs, extra & 7) = dst_hi;
  841.     else if ((dst_hi != 0 || (dst_lo & 0x80000000) != 0)
  842.          && ((dst_hi & 0xffffffff) != 0xffffffff
  843.              || (dst_lo & 0x80000000) != 0x80000000)) 
  844.     {
  845.         VFLG = 1;
  846.     }
  847.     m68k_dreg(regs, (extra >> 12) & 7) = dst_lo;
  848.     } else {
  849.     /* unsigned */
  850.     uae_u32 dst_lo,dst_hi;
  851.  
  852.     mul_unsigned(src,(uae_u32)m68k_dreg(regs, (extra >> 12) & 7),&dst_hi,&dst_lo);
  853.     
  854.     VFLG = CFLG = 0;
  855.     ZFLG = dst_hi == 0 && dst_lo == 0;
  856.     NFLG = ((uae_s32)dst_hi) < 0;
  857.     if (extra & 0x400)
  858.         m68k_dreg(regs, extra & 7) = dst_hi;
  859.     else if (dst_hi != 0) {
  860.         VFLG = 1;
  861.     }
  862.     m68k_dreg(regs, (extra >> 12) & 7) = dst_lo;
  863.     }
  864. #endif
  865. }
  866. static char* ccnames[] =
  867. { "T ","F ","HI","LS","CC","CS","NE","EQ",
  868.   "VC","VS","PL","MI","GE","LT","GT","LE" };
  869.  
  870. void m68k_reset(void)
  871. {
  872.     m68k_areg(regs, 7) = get_long(0x00f80000);
  873.     m68k_setpc(get_long(0x00f80004));
  874.     regs.kick_mask = 0xF80000;
  875.     regs.s = 1;
  876.     regs.m = 0;
  877.     regs.stopped = 0;
  878.     regs.t1 = 0;
  879.     regs.t0 = 0;
  880.     ZFLG = CFLG = NFLG = VFLG = 0;
  881.     regs.spcflags = 0;
  882.     regs.intmask = 7;
  883.     regs.vbr = regs.sfc = regs.dfc = 0;
  884.     regs.fpcr = regs.fpsr = regs.fpiar = 0;
  885.     customreset();
  886. }
  887.  
  888. void REGPARAM2 op_illg(uae_u32 opcode)
  889. {
  890.     compiler_flush_jsr_stack();
  891.     if (opcode == 0x4E7B && get_long(0x10) == 0 
  892.     && (m68k_getpc() & 0xF80000) == 0xF80000) 
  893.     {
  894.     write_log("Your Kickstart requires a 68020 CPU. Giving up.\n");
  895.     broken_in = 1; 
  896.     regs.spcflags |= SPCFLAG_BRK;
  897.     quit_program = 1;
  898.     }
  899.     if (opcode == 0xFF0D) {
  900.     if ((m68k_getpc() & 0xF80000) == 0xF80000) {
  901.         /* This is from the dummy Kickstart replacement */
  902.         ersatz_perform (nextiword ());
  903.         return;
  904.     } else if ((m68k_getpc() & 0xF80000) == 0xF00000) {
  905.         /* User-mode STOP replacement */
  906.         m68k_setstopped(1);
  907.         return;
  908.     }
  909.     }
  910. #ifdef USE_POINTER
  911.     regs.pc_p -= 2;
  912. #else
  913.     regs.pc -= 2;
  914. #endif
  915.     fill_prefetch();
  916.     if ((opcode & 0xF000) == 0xF000) {
  917.     Exception(0xB,0);
  918.     return;
  919.     }
  920.     if ((opcode & 0xF000) == 0xA000) {
  921.         Exception(0xA,0);
  922.     return;
  923.     }
  924.     sprintf (warning_buffer, "Illegal instruction: %04x at %08lx\n", opcode, m68k_getpc());
  925.     write_log (warning_buffer);
  926.     Exception(4,0);
  927. }
  928.  
  929. void mmu_op(uae_u32 opcode, uae_u16 extra)
  930. {
  931.     if ((extra & 0xB000) == 0) { /* PMOVE instruction */
  932.  
  933.     } else if ((extra & 0xF000) == 0x2000) { /* PLOAD instruction */
  934.     } else if ((extra & 0xF000) == 0x8000) { /* PTEST instruction */
  935.     } else
  936.     op_illg(opcode);
  937. }
  938.  
  939. static int n_insns=0, n_spcinsns=0;
  940.  
  941. static uaecptr last_trace_ad = 0;
  942.  
  943. static __inline__ void do_trace(void)
  944. {
  945.     if (regs.spcflags & SPCFLAG_TRACE) {        /* 6 */
  946.     if (regs.t0) {
  947.         uae_u16 opcode;
  948.         /* should also include TRAP, CHK, SR modification FPcc */
  949.         /* probably never used so why bother */
  950.         /* We can afford this to be inefficient... */
  951.         m68k_setpc(m68k_getpc());
  952.         opcode = get_word(regs.pc);
  953.         if (opcode == 0x4e72         /* RTE */
  954.         || opcode == 0x4e74         /* RTD */
  955.         || opcode == 0x4e75         /* RTS */
  956.         || opcode == 0x4e77         /* RTR */
  957.         || opcode == 0x4e76         /* TRAPV */
  958.         || (opcode & 0xffc0) == 0x4e80     /* JSR */
  959.         || (opcode & 0xffc0) == 0x4ec0     /* JMP */
  960.         || (opcode & 0xff00) == 0x6100  /* BSR */
  961.         || ((opcode & 0xf000) == 0x6000    /* Bcc */
  962.             && cctrue((opcode >> 8) & 0xf)) 
  963.         || ((opcode & 0xf0f0) == 0x5050 /* DBcc */
  964.             && !cctrue((opcode >> 8) & 0xf) 
  965.             && (uae_s16)m68k_dreg(regs, opcode & 7) != 0)) 
  966.         {
  967.         last_trace_ad = m68k_getpc();
  968.         regs.spcflags &= ~SPCFLAG_TRACE;
  969.         regs.spcflags |= SPCFLAG_DOTRACE;
  970.         }
  971.     } else if (regs.t1) {
  972.         last_trace_ad = m68k_getpc();
  973.         regs.spcflags &= ~SPCFLAG_TRACE;
  974.         regs.spcflags |= SPCFLAG_DOTRACE;
  975.     }
  976.     }
  977. }
  978.  
  979. static void m68k_run_1(void)
  980. {
  981.     for(;;) {
  982.     uae_u32 opcode = nextiword();
  983.  
  984.     /* assert (!regs.stopped && !(regs.spcflags & SPCFLAG_STOP)); */
  985. /*    regs_backup[backup_pointer = (backup_pointer + 1) % 16] = regs;*/
  986. #if COUNT_INSTRS
  987.     instrcount[opcode]++;
  988. #endif
  989. #if defined(X86_ASSEMBLY)
  990.     __asm__ __volatile__("\tcall *%%ebx"
  991.                  : : "b" (cpufunctbl[opcode]), "a" (opcode)
  992.                  : "%eax", "%ebx", "%edx", "%ecx", 
  993.                  "%esi", "%edi", "%ebp", "memory", "cc");
  994. #else
  995.     (*cpufunctbl[opcode])(opcode);
  996. #endif
  997. #ifndef NO_EXCEPTION_3
  998.     if (buserr) {
  999.         last_op_for_exception_3 = opcode;
  1000.         Exception(3,0);
  1001.         buserr = 0;
  1002.     }
  1003. #endif
  1004.     /*n_insns++;*/
  1005.     do_cycles();
  1006.     if (regs.spcflags) {
  1007.         /*n_spcinsns++;*/
  1008.         while (regs.spcflags & SPCFLAG_BLTNASTY) {
  1009.         do_cycles();
  1010.         if (regs.spcflags & SPCFLAG_DISK)
  1011.             do_disk();
  1012.         }
  1013.         run_compiled_code();
  1014.         if (regs.spcflags & SPCFLAG_DOTRACE) {
  1015.         Exception(9,last_trace_ad);
  1016.         }
  1017.         while (regs.spcflags & SPCFLAG_STOP) {
  1018.         do_cycles();
  1019.         if (regs.spcflags & SPCFLAG_DISK)
  1020.             do_disk();
  1021.         if (regs.spcflags & (SPCFLAG_INT | SPCFLAG_DOINT)){
  1022.             int intr = intlev();
  1023.             regs.spcflags &= ~(SPCFLAG_INT | SPCFLAG_DOINT);
  1024.             if (intr != -1 && intr > regs.intmask) {
  1025.             Interrupt(intr);
  1026.             regs.stopped = 0;
  1027.             regs.spcflags &= ~SPCFLAG_STOP;
  1028.             }
  1029.         }
  1030.         }
  1031.         do_trace();
  1032. #ifdef WANT_SLOW_MULTIPLY
  1033.         /* Kludge for Hardwired demo. The guys who wrote it should be
  1034.          * mutilated. */
  1035.         if (regs.spcflags & SPCFLAG_EXTRA_CYCLES) {
  1036.         do_cycles (); do_cycles (); do_cycles (); do_cycles ();
  1037.         regs.spcflags &= ~SPCFLAG_EXTRA_CYCLES;
  1038.         }
  1039. #endif
  1040.         if (regs.spcflags & SPCFLAG_DISK)
  1041.         do_disk();
  1042.  
  1043.         if (regs.spcflags & SPCFLAG_DOINT) {
  1044.         int intr = intlev();
  1045.         regs.spcflags &= ~SPCFLAG_DOINT;
  1046.         if (intr != -1 && intr > regs.intmask) {
  1047.             Interrupt(intr);
  1048.             regs.stopped = 0;
  1049.         }        
  1050.         }
  1051.         if (regs.spcflags & SPCFLAG_INT) {
  1052.         regs.spcflags &= ~SPCFLAG_INT;
  1053.         regs.spcflags |= SPCFLAG_DOINT;
  1054.         }
  1055.         if (regs.spcflags & (SPCFLAG_BRK|SPCFLAG_MODE_CHANGE)) {
  1056.         regs.spcflags &= ~(SPCFLAG_BRK|SPCFLAG_MODE_CHANGE);
  1057.         return;
  1058.         }
  1059.     }
  1060.     }
  1061. }
  1062.  
  1063. #if USER_PROGRAMS_BEHAVE > 0
  1064. static void m68k_run_2(void)
  1065. {
  1066.     for(;;) {
  1067.     uae_u32 opcode = nextiword();
  1068.  
  1069.     /* assert (!regs.stopped && !(regs.spcflags & SPCFLAG_STOP)); */
  1070. /*    regs_backup[backup_pointer = (backup_pointer + 1) % 16] = regs;*/
  1071. #if COUNT_INSTRS
  1072.     instrcount[opcode]++;
  1073. #endif
  1074. #if defined(X86_ASSEMBLY)
  1075.     __asm__ __volatile__("\tcall *%%ebx"
  1076.                  : : "b" (cpufunctbl_behaved[opcode]), "a" (opcode)
  1077.                  : "%eax", "%ebx", "%edx", "%ecx", 
  1078.                  "%esi", "%edi", "%ebp", "memory", "cc");
  1079. #else
  1080.     (*cpufunctbl_behaved[opcode])(opcode);
  1081. #endif
  1082. #ifndef NO_EXCEPTION_3
  1083.     if (buserr) {
  1084.         last_op_for_exception_3 = opcode;
  1085.         Exception(3,0);
  1086.         buserr = 0;
  1087.     }
  1088. #endif
  1089.     /*n_insns++;*/
  1090.     do_cycles();    
  1091.     if (regs.spcflags) {
  1092.         /*n_spcinsns++;*/
  1093.         while (regs.spcflags & SPCFLAG_BLTNASTY) {
  1094.         do_cycles();
  1095.         if (regs.spcflags & SPCFLAG_DISK)
  1096.             do_disk();
  1097.         }
  1098.         run_compiled_code();
  1099.         if (regs.spcflags & SPCFLAG_DOTRACE) {
  1100.         Exception(9,last_trace_ad);
  1101.         }
  1102.         while (regs.spcflags & SPCFLAG_STOP) {
  1103.         do_cycles();
  1104.         if (regs.spcflags & SPCFLAG_DISK)
  1105.             do_disk();
  1106.         if (regs.spcflags & (SPCFLAG_INT | SPCFLAG_DOINT)){
  1107.             int intr = intlev();
  1108.             regs.spcflags &= ~(SPCFLAG_INT | SPCFLAG_DOINT);
  1109.             if (intr != -1 && intr > regs.intmask) {
  1110.             Interrupt(intr);
  1111.             regs.stopped = 0;
  1112.             regs.spcflags &= ~SPCFLAG_STOP;
  1113.             }
  1114.         }
  1115.         }
  1116.         do_trace();
  1117. #ifdef WANT_SLOW_MULTIPLY
  1118.         /* Kludge for Hardwired demo. The guys who wrote it should be
  1119.          * mutilated. */
  1120.         if (regs.spcflags & SPCFLAG_EXTRA_CYCLES) {
  1121.         do_cycles (); do_cycles (); do_cycles (); do_cycles ();
  1122.         regs.spcflags &= ~SPCFLAG_EXTRA_CYCLES;
  1123.         }
  1124. #endif
  1125.         if (regs.spcflags & SPCFLAG_DISK)
  1126.         do_disk();
  1127.  
  1128.         if (regs.spcflags & SPCFLAG_DOINT) {
  1129.         int intr = intlev();
  1130.         regs.spcflags &= ~SPCFLAG_DOINT;
  1131.         if (intr != -1 && intr > regs.intmask) {
  1132.             Interrupt(intr);
  1133.             regs.stopped = 0;
  1134.         }
  1135.         }
  1136.         if (regs.spcflags & SPCFLAG_INT) {
  1137.         regs.spcflags &= ~SPCFLAG_INT;
  1138.         regs.spcflags |= SPCFLAG_DOINT;
  1139.         }
  1140.         if (regs.spcflags & (SPCFLAG_BRK|SPCFLAG_MODE_CHANGE)) {
  1141.         regs.spcflags &= ~(SPCFLAG_BRK|SPCFLAG_MODE_CHANGE);
  1142.         return;
  1143.         }
  1144.     }
  1145.     }
  1146. }
  1147. #endif
  1148.  
  1149. #ifdef X86_ASSEMBLY
  1150. static __inline__ void m68k_run1(void)
  1151. {
  1152.     /* Work around compiler bug: GCC doesn't push %ebp in m68k_run_1. */
  1153.     __asm__ __volatile__ ("pushl %%ebp\n\tcall *%%eax\n\tpopl %%ebp" : : "a" (m68k_run_1) : "%eax", "%edx", "%ecx", "memory", "cc");
  1154. }
  1155. #if USER_PROGRAMS_BEHAVE > 0
  1156. static __inline__ void m68k_run2(void)
  1157. {
  1158.     /* Work around compiler bug: GCC doesn't push %ebp in m68k_run_1. */
  1159.     __asm__ __volatile__ ("pushl %%ebp\n\tcall *%%eax\n\tpopl %%ebp" : : "a" (m68k_run_2) : "%eax", "%edx", "%ecx", "memory", "cc");
  1160. }
  1161. #endif
  1162. #else
  1163. #define m68k_run1 m68k_run_1
  1164. #define m68k_run2 m68k_run_2
  1165. #endif
  1166.  
  1167. int in_m68k_go = 0;
  1168.  
  1169. void m68k_go(int may_quit)
  1170. {
  1171.     if (in_m68k_go || !may_quit) {
  1172.     write_log("Bug! m68k_go is not reentrant.\n");
  1173.     abort();
  1174.     }
  1175.  
  1176.     in_m68k_go++;
  1177.     for(;;) {
  1178.     if (quit_program > 0) {
  1179.         if (quit_program == 1)
  1180.         break;
  1181.         quit_program = 0;
  1182.         m68k_reset();
  1183.     }
  1184.     if (debugging)
  1185.         debug();
  1186. #if USER_PROGRAMS_BEHAVE > 0
  1187.     if ((regs.kick_mask & 0xF00000) != 0xF00000)
  1188.         m68k_run2();
  1189.     else
  1190. #endif
  1191.         m68k_run1();
  1192.     }
  1193.     in_m68k_go--;
  1194. }
  1195.  
  1196. void m68k_disasm(uaecptr addr, uaecptr *nextpc, int cnt)
  1197. {
  1198.     uaecptr pc = m68k_getpc();
  1199.     uaecptr newpc = 0;
  1200.     m68k_setpc(addr);
  1201.     for (;cnt--;){
  1202.     char instrname[20],*ccpt;
  1203.     int opwords;
  1204.     uae_u32 opcode;
  1205.     struct mnemolookup *lookup;
  1206.     struct instr *dp;
  1207.     printf("%08lx: ", m68k_getpc());
  1208.     for(opwords = 0; opwords < 5; opwords++){
  1209.         printf("%04x ", get_word(m68k_getpc() + opwords*2));
  1210.     }
  1211.     
  1212.     opcode = nextiword();
  1213.     if (cpufunctbl[opcode] == op_illg) {
  1214.         opcode = 0x4AFC;
  1215.     }
  1216.     dp = table68k + opcode;
  1217.     for (lookup = lookuptab;lookup->mnemo != dp->mnemo; lookup++)
  1218.         ;
  1219.     
  1220.     strcpy(instrname,lookup->name);
  1221.     ccpt = strstr(instrname,"cc");
  1222.     if (ccpt != 0) {
  1223.         strncpy(ccpt,ccnames[dp->cc],2);
  1224.     }
  1225.     printf("%s", instrname);
  1226.     switch(dp->size){
  1227.      case sz_byte: printf(".B "); break;
  1228.      case sz_word: printf(".W "); break;
  1229.      case sz_long: printf(".L "); break;
  1230.      default: printf("   ");break;
  1231.     }
  1232.  
  1233.     if (dp->suse) {
  1234.         newpc = m68k_getpc() + ShowEA(dp->sreg, dp->smode, dp->size, 0);
  1235.     }
  1236.     if (dp->suse && dp->duse)
  1237.         printf(",");
  1238.     if (dp->duse) {
  1239.         newpc = m68k_getpc() + ShowEA(dp->dreg, dp->dmode, dp->size, 0);
  1240.     }
  1241.     if (ccpt != 0) {
  1242.         if (cctrue(dp->cc))
  1243.         printf(" == %08lx (TRUE)",newpc);
  1244.         else 
  1245.         printf(" == %08lx (FALSE)",newpc);
  1246.     } else if ((opcode & 0xff00) == 0x6100) /* BSR */
  1247.         printf(" == %08lx",newpc);
  1248.     printf("\n");
  1249.     }
  1250.     if (nextpc) *nextpc = m68k_getpc();
  1251.     m68k_setpc(pc);
  1252. }
  1253.  
  1254. void m68k_dumpstate(uaecptr *nextpc)
  1255. {
  1256.     int i;
  1257.     for(i = 0; i < 8; i++){
  1258.     printf("D%d: %08lx ", i, m68k_dreg(regs, i));
  1259.     if ((i & 3) == 3) printf("\n");
  1260.     }
  1261.     for(i = 0; i < 8; i++){
  1262.     printf("A%d: %08lx ", i, m68k_areg(regs, i));
  1263.     if ((i & 3) == 3) printf("\n");
  1264.     }
  1265.     if (regs.s == 0) regs.usp = m68k_areg(regs, 7);
  1266.     if (regs.s && regs.m) regs.msp = m68k_areg(regs, 7);
  1267.     if (regs.s && regs.m == 0) regs.isp = m68k_areg(regs, 7);
  1268.     printf("USP=%08lx ISP=%08lx MSP=%08lx VBR=%08lx\n",
  1269.         regs.usp,regs.isp,regs.msp,regs.vbr);
  1270.     printf ("T=%d%d S=%d M=%d X=%d N=%d Z=%d V=%d C=%d IMASK=%d\n",
  1271.         regs.t1, regs.t0, regs.s, regs.m,
  1272.         XFLG, NFLG, ZFLG, VFLG, CFLG, regs.intmask);
  1273.     for(i = 0; i < 8; i++){
  1274.     printf("FP%d: %g ", i, regs.fp[i]);
  1275.     if ((i & 3) == 3) printf("\n");
  1276.     }
  1277.     printf("N=%d Z=%d I=%d NAN=%d\n",
  1278.         (regs.fpsr & 0x8000000) != 0,
  1279.         (regs.fpsr & 0x4000000) != 0,
  1280.         (regs.fpsr & 0x2000000) != 0,
  1281.         (regs.fpsr & 0x1000000) != 0);
  1282.     m68k_disasm(m68k_getpc(), nextpc, 1);
  1283.     if (nextpc) printf("next PC: %08lx\n", *nextpc);
  1284. }
  1285.